/**
  * Author: Mei
  * Date: 2021-01-08 11:28
  * Description: 
  *
  */
#include "../head.h"
struct Any {
    Any(void) : m_tpIndex(type_index(typeid(void))) {}

    Any(const Any &that) : m_ptr(that.Clone()), m_tpIndex(that.m_tpIndex) {}

    Any(Any &&that) : m_ptr(move(that.Clone())), m_tpIndex(move(that.m_tpIndex)) {}

    //创建智能指针时，对于一般的类型，通过std::decay来移除引用和cv符，从而获取原始类型
    template<typename U, //当U不为Any时成立
            class = typename enable_if<!is_same<typename decay<U>::type, Any>::value, U>::type>
    Any(U &&value) : m_ptr(new Derived<typename decay<U>::type>(forward<U>(value))),
                     m_tpIndex(type_index(typeid(typename decay<U>::type))) {
    }

    bool IsNull() const { //为空返回false
        return !bool(m_ptr);
    }

    template<class U>
    bool Is() const {
        return m_tpIndex == type_index(typeid(U));
    }

    //将Any转换为实际的类型
    template<class U>
    U &AnyCast() {
        if (!Is<U>()) {
            cout << "can not cast " << typeid(U).name() << " to " << m_tpIndex.name() << endl;
        }
        auto derived = dynamic_cast<Derived <U> *>(m_ptr.get());
        return derived->m_value;
    }

    Any &operator=(const Any &a) {
        if (m_ptr == a.m_ptr) {
            return *this;
        }
        m_ptr = a.Clone();
        m_tpIndex = a.m_tpIndex;
        return *this;
    }

private:
    struct Base;
    typedef unique_ptr<Base> BasePtr;

    struct Base {
        virtual ~Base() {}

        virtual BasePtr Clone() const = 0;
    };

    template<typename T>
    struct Derived : Base {
        template<typename U>
        Derived(U &&value) : m_value(forward<U>(value)) {
        }

        BasePtr Clone() const {
            return BasePtr(new Derived<T>(m_value));
        }

        T m_value;
    };

    BasePtr Clone() const {
        if (m_ptr != nullptr) {
            return m_ptr->Clone();
        }
        return nullptr;
    }

    BasePtr m_ptr;
    std::type_index m_tpIndex;
};